Dependently-Typed Formalisation of Typed Term Graphs

The Coconut project [AK09a, AK09b] uses “code graphs” [KAC06], a variant of term graphs in the spirit of “jungles” [HP91, CR93], as intermediate presentation for the generation of highly optimised assembly code. This is currently implemented in Haskell, and we use the Haskell type system in an embedded domain-specific language (EDSL) for creating such code graphs via what appears to be standard Haskell function definitions, with let-definitions introducing sharing, and with functions representing assemblylevel operations constructing hyperedges [AK09a]. However, since Haskell does not support full dependent typing, the intermediate term graph datatype interface, supporting graph navigation, traversal, and manipulation operations, cannot preserve the connection with the Haskell-level typing of the assembly operations. Therefore, although EDSL-created code graphs are well-typed by construction, as certified by the type checker, this does not hold anymore for code graphs that are the result of internal operations. Those internal operations either require separate proof that they preserve well-typedness, or they need to perform run-time checks, at considerable run-time cost. In addition, our code-graph-creation EDSL has a second “simulator” implementation, which turns the EDSL expressions into Haskell functions that implement a “machine simulation”. Since the code graph representation has lost its connection with the Haskell-level typing, it is “unintuitively hard” to use the simulation machinery for code graphs that result from code graph manipulation operations. Mainly for these reasons, we are now exploring implementation of code graphs in a dependently typed programming language, where there is no need to “loose” the type information when moving to a graph representation, and where even stronger assertions about operations on code graphs than just type preservation can be proven inside the implementing system. We start, in Sect. 2, with a quick introduction to the dependently typed programming language (and proof checker) Agda [Nor07]. This is followed by formalisations of set-based mathematical definitions of untyped (Sect. 3) and typed (Sect. 4) term graphs, and then a summary of the gs-monoidal category view on these term graphs in Sect. 5. Finally, we present two formalisations of acyclic term graphs as (differently structured) nested let-expressions (Sections 6 and 7).